/*
 * SoulUtil 
 * version:v0.0.1
 */

AjaxUtil = {
    // 判断是否登录
    isLogin: function (token) {
        return AjaxUtil.getJson("staff/isLogin");
    },

    preDeal: function (resp) { // 预处理请求结果
        if (resp == null) {
            SwalUtil.error("请求失败,请刷新浏览器后重试!");
            return null;
        }
        if (resp.code == 200) { // 成功
            return resp;
        }

        if (resp.code == 422) { // 还没有登录,跳转到登录的页面
            SwalUtil.error("您还没有登录,请先登录!");
            setTimeout(function () { // 延时2s后执行
                window.location.href = BaseConfig.loginUrl;
            }, 1500);
            return null;
        }
        if (resp.code == 403) { // 没有权限
            SwalUtil.error("没有权限,请联系管理员!");
            return null;
        }

        if (resp.code == 412) { // 参数错误!
            SwalUtil.error(resp.msg);
            return null;
        }

        SwalUtil.error(resp.msg);
        return null;
    },

    // 获取对象(get请求)
    getJson: function (url, params) {
        if (params) {
            url = BaseConfig.preUrl + url + '?token=' + BaseConfig.token + '&' + params;
        } else {
            url = BaseConfig.preUrl + url + '?token=' + BaseConfig.token
        }
        try {
            var obj = $.ajax({
                url: url,
                async: false,
                dataType: 'json',
                error: function () {
                    SwalUtil.error("请求失败,请刷新浏览器后重试!");
                    return null;
                }
            });

            return AjaxUtil.preDeal(obj.responseJSON);
        } catch (e) {
            SwalUtil.error("请求失败,请刷新浏览器后重试!");
            return null;
        }
    },

    // post获取json
    postJson: function (url, params) {
        try {
            var obj = $.ajax({
                url: BaseConfig.preUrl + url + '?token=' + BaseConfig.token,
                async: false,
                type: "POST",
                data: params,
                dataType: 'json',
                contentType: "application/x-www-form-urlencoded;charset=utf-8",


                error: function (responseText, status, statusText) {
                    console.log(statusText);
                    SwalUtil.error("请求失败,请刷新浏览器后重试!");
                    return null;
                }
            });
            return AjaxUtil.preDeal(obj.responseJSON);
        } catch (e) {
            SwalUtil.error("请求失败,请刷新浏览器后重试!");
            return null;
        }
    }
};

SwalUtil = {
    // 基础提示信息,1000ms后自动关闭
    basic: function (msg) {
        swal({
            title: msg,
            showConfirmButton: false,
            timer: 1000,
        }).then(function () {
        }, function (dismiss) {
        });
    },
    // 成功的提示消息,600ms后自动关闭
    success: function (msg) {
        swal({
            title: msg,
            type: "success",
            confirmButtonText: '确定',
            timer: 2000
        }).then(function () {
        }, function (dismiss) {
        });
    },
    // 错误的提示消息不自动关闭
    error: function (msg) {
        swal({
            title: msg,
            confirmButtonText: '确定',
            type: "error",
        });
    },
    // 确定提示框
    confirm: function (onConfirm, title, text) {
        if (!title) {
            title = '您确定要执行该操作吗?';
        }
        if (!text) {
            text = '该操作无法撤销!'
        }
        swal({
            title: title,
            text: text,
            type: 'warning',
            showCancelButton: true,
            confirmButtonText: '确定',
            cancelButtonText: '取消',
        }).then(onConfirm, function (dismiss) {
        });
    },
    // showLoading
    showLoading: function () {
        swal.showLoading();
    },
    // hideLoading
    hideLoading: function () {
        swal.hideLoading();
    }
};

ParamUtil = {
    // 获取GET参数
    getQueryString: function (name) {
        var reg = new RegExp("(^|&)" + name + "=([^&]*)(&|$)");
        var r = window.location.search.substr(1).match(reg);
        if (r != null)
            return decodeURI(r[2]);
        return null;
    },
    // 校验是否是数字
    isNum: function (str) {
        var reg = new RegExp("^\d{n}$");
        return reg.test(str);
    }
};

FormatUtil = {
    // 将时间ms值转化为'yyyy-MM-dd'格式的字符串
    formatDate: function (ms) {
        if (isNaN(ms)) { //不是一个数字(时间戳),返回原值
            return ms;
        }
        var d = new Date(ms);
        var year = d.getFullYear();
        var month = d.getMonth() + 1;
        if (month < 10) {
            month = '0' + month;
        }
        var date = d.getDate();
        if (date < 10) {
            date = '0' + date;
        }
        return year + "-" + month + "-" + date;
    },

    // 将时间ms值转化为'HH:mm'格式的字符串
    formatTime: function (ms) {
        if (isNaN(ms)) { //不是一个数字(时间戳),返回原值
            return ms;
        }
        var d = new Date(ms);
        var hour = d.getHours();
        if (hour < 10) {
            hour = '0' + hour;
        }
        var minute = d.getMinutes();
        if (minute < 10) {
            minute = '0' + minute;
        }
        return hour + ":" + minute;
    },

    // 将时间ms值转化为'yyyy-MM-dd HH:mm:ss'格式的字符串
    formatDateTime: function (ms) {
        if (isNaN(ms)) { //不是一个数字(时间戳),返回原值
            return ms;
        }
        var d = new Date(ms);
        var year = d.getFullYear();
        var month = d.getMonth() + 1;
        if (month < 10) {
            month = '0' + month;
        }
        var date = d.getDate();
        if (date < 10) {
            date = '0' + date;
        }
        var hour = d.getHours();
        if (hour < 10) {
            hour = '0' + hour;
        }
        var minute = d.getMinutes();
        if (minute < 10) {
            minute = '0' + minute;
        }
        var second = d.getSeconds();
        if (second < 10) {
            second = '0' + second;
        }
        return year + "-" + month + "-" + date + " " + hour + ":" + minute + ":" + second;
    },

    formatPreMonth: function (ms) {
        var d = new Date(ms);
        var year = d.getFullYear();
        var month = d.getMonth() + 1;
        if (month == 1) {
            month = 12;
            year--;
        } else {
            month--;
        }
        if (month < 10) {
            month = '0' + month;
        }
        var date = d.getDate();
        if (date < 10) {
            date = '0' + date;
        }
        return year + "-" + month + "-" + date;
    },
    // 将单位为分的金额格式化为2个小数
    formatMoney2: function (money) {
        return (money / 100).toFixed(2);
    },

    formatMoney: function (money) {
        var re = /^[0-9]+.?[0-9]*$/; // 判断字符串是否为数字 //判断正整数 /^[1-9]+[0-9]*]*$/
        if (!re.test(money)) {
            return 0;
        }
        // 判断商品价格
        var reg = /(^[-+]?[1-9]\d*(\.\d{1,2})?$)|(^[-+]?[0]{1}(\.\d{1,2})?$)/;
        if (!reg.test(money)) {
            return (money / 1).toFixed(2);
        } else {
            return money;
        }
    },
    // 将单位为元的金额转为金额为分的值
    formatMoney2Point: function (money) {
        money = money * 100;
        return parseInt(money);
    }
};

FormUtil = {
    createSelectItem: function (items, selected) {
        var str = '';
        for (var i in items) {
            if (items[i].value == selected) {
                str += '<option value="' + items[i].value + '" selected>' + items[i].name + '</option>';
            } else {
                str += '<option value="' + items[i].value + '">' + items[i].name + '</option>';
            }
        }
        return str;
    }
};

LogUtil = {
    log: function (msg, src) {
        if (BaseConfig.debug) {
            if (src) {
                console.log('[' + new Date().getTime() + '] >> ' + src + ':' + msg);
            } else {
                console.log('未指定模块输出:' + msg);
            }
        }
    }
};

SetUtil = {
    set2string: function (set) {
        var str = '';
        if (!set) {
            return str;
        }
        set.forEach(function (value, key, map) {
            str += value + '-';
        });
        return str.substring(0, str.length - 1)
    },
    string2set: function (str) {
        var set = new Set();
        if (!str) {
            return set;
        }
        var arr = str.split("-");
        for (var i = 0; i < arr.length; i++) {
            set.add(arr[i]);
        }
        return set;
    },
    addString: function (old, str) {
        var set = SetUtil.string2set(old);
        set.add(str);
        return SetUtil.set2string(set);
    }
};

JsTreeUtil = {
    getCheck: function (el) {// 获取选中的节点的Id
        var priv_ids = [];
        var items = $(el + " [aria-level='1']");// 选取一级树
        for (var i = 0; i < items.length; i++) {
            if ($(items[i]).find('.jstree-undetermined').length != 0) {
                priv_ids.push($(items[i]).attr('id'));// 获取半选的Id
            }
        }
        privs = $(el).jstree().get_checked();
        for (var i = 0; i < privs.length; i++) {
            priv_ids.push(privs[i]);
        }

        // 拼接成需要的字符串形式
        var privs = "";
        for (var j = 0; j < priv_ids.length; j++) {
            privs += priv_ids[j] + "-";
        }
        return privs;
    },
    /**
     * 生成权限树
     * el : 生产树的节点
     * privs : 树的全部数据,Privilege数组
     * privIds : 已勾选的IdStr,100000-110000-111000
     */
    createPrivTree: function (el, privs, privIds) {
        try {
            if ($(el).jstree()) {
                $(el).jstree().destroy();
            }
        } catch (e) {
            console.log(e);
        }
        var tree_data = "["; // 树json字符串
        var privIdArr = []; // 已勾选的Id数组
        if (privIds) {
            privIdArr = privIds.split("-");//已勾选的权限
        }
        var parentId = '';
        for (var i = 0; i < privs.length; i++) {
            if (privs[i].parentId == null) {
                parentId = "#";
            } else {
                parentId = privs[i].parentId;
            }
            if (privIdArr.indexOf(privs[i].privilegeId.toString()) != -1 && privs[i].privilegeId % 10000 != 0) {
                tree_data += '{"id" : "'
                    + privs[i].privilegeId
                    + '","parent" : "'
                    + parentId
                    + '","text":"'
                    + privs[i].name
                    + '","state" : { "opened" : true,"selected" : true}},';
            } else {
                tree_data += '{"id" : "'
                    + privs[i].privilegeId
                    + '","parent" : "'
                    + parentId
                    + '","text":"'
                    + privs[i].name
                    + '","state" : { "opened" : true,"selected" : false}},';
            }
        }
        tree_data = tree_data.substring(0, tree_data.length - 1);
        tree_data += "]";
        $(el).jstree({
            'plugins': ["checkbox"],
            'core': {
                'data': $.parseJSON(tree_data)
            }
        })
        return true;
    }
}


FileinputUtil = {
    /**
     * 初始化图片上传插件(fileinput)
     * el:jQuery选择器
     * module:即将上传到服务器的模块名
     * maxFileCount:最大的文件数量
     */
    initImagesUpload: function (el, module, maxFileCount) {
        LogUtil.log('开始初始化图片上传插件:使用参数-->el:' + el + ';module:' + module + ';maxFileCount:' + maxFileCount, 'FileinputUtil#init()')
        $(el + '_fileinput').fileinput({
            language: 'zh', // 设置语言
            uploadUrl: BaseConfig.preUrl + 'upload/image?module=' + module + '&token=' + BaseConfig.token, // 上传的地址
            allowedFileExtensions: ['jpg', 'gif', 'png'], // 接收的文件后缀
            allowedPreviewTypes: ['image'],
            fileActionSettings: {
                showUpload: false,
                showRemove: false,
            },
            showUpload: true, // 是否显示上传按钮
            showCaption: true, // 是否显示标题
            showRemove: true,
            showUploadedThumbs: true,
            maxFileCount: maxFileCount, // 表示允许同时上传的最大文件个数
            enctype: 'multipart/form-data',
            msgFilesTooMany: "选择上传的文件数量({n}) 超过允许的最大数值{m}！",
            initialPreviewShowDelete: false,
            overwriteInitial : false,
            validateInitialCount:true,
            // initialPreview: ['<img style="width:100%;height:100%" src="http://wx4.sinaimg.cn/large/006PskY0ly1fm14x7zz9sj30m30cdac4.jpg" class="file-preview-image">',
            //         '<img style="width:100%;height:100%" src="http://wx3.sinaimg.cn/large/006PskY0gy1fjsk8ogehtj30m30cd43a.jpg" class="file-preview-image">'],
        }).on('fileuploaded', function (event, data, previewId, index) {
            LogUtil.log('用户点击了上传文件按钮', 'FileinputUtil#init()->onFileuploaded')
            var resp = data.response;
            if (resp && resp.code == 200) {
                var photostr = SetUtil.addString($(el).val(), resp.obj);
                LogUtil.log(el + '=' + photostr, 'FileinputUtil#init()->onFileuploaded')
                $(el).val(photostr);
            }
        }).on('filecleared', function (event) { // 清除文件
            LogUtil.log('用户点击了移除按钮', 'FileinputUtil#init()->onFilecleared')
            $(el).val('');
        }).on('fileselect',function () {
            LogUtil.log('用户选择了新的图片', 'FileinputUtil#init()->fileselect')
        });
    },
    initPreview: function (module,dirt ,imagesStr) {
        if(!imagesStr) return;
        var images = imagesStr.split('-');
        var html = '';
        for (var i = 0; i < images.length; i++) {
            if (images[i]) {
                html += '<div class="file-preview-frame krajee-default"><div class="kv-file-content"><a href="#" class="thumbnail" style="max-width:100%;height:100%" ><img src="/resource/images/'+ dirt+ '/' + images[i] + '" style="max-width:100%;height:100%;" class="file-preview-image"/></a></div></div>'
            }
        }
        $('#' + module + '_modal_edit .file-drop-zone-title').remove();
        $('#' + module + '_modal_edit .file-preview-thumbnails').html(html);
        $('.thumbnail img').zoomify({
            scale: 1
        });
    }
}

/**
 *  bootstrapTable通用工具集合
 */
BootstrapTableUtil = {
    // 格式化相关
    formatter: {
        // 将时间戳格式化成日期形式(yyyy-MM-dd)
        date: function (value, row, index) {
            return FormatUtil.formatDate(value);
        },
        // 将时间戳格式化成日期形式(yyyy-MM-dd hh:mm)
        datetime: function (value, row, index) {
            return FormatUtil.formatDateTime(value);
        },
        // 将true转化为'是',false:'否';
        boolean: function (value, row, index) {
            if (value) {
                return '是';
            } else {
                return '否';
            }
        },
        money: function (value, row, index) {
            return FormatUtil.formatMoney2(value);
        },
        // 将图片路径格式化成图片
        image: function (value, module, height) {
            if (value) {
                var path = '/resource/images/' + module + '/' + value;
                var html = '<img height = "' + height + 'px" src="' + path + '">';
                return html;
            } else {
                return '暂无图片'
            }
        }
    },

}


/**
 * 创建单表格的页面
 * @param module
 * @param query
 * @param toolbar
 * @param formElement
 * @param bootstrapTable
 */
SingleTablePageCreateUtil = {
    createInstance: function (module, query, toolbar, formElement, bootstrapTable, config) {
        var page = {};
        var defaults = {
            listUrl: module + '/list', // 默认的列表Url
            addUrl: module + '/add', // 默认的添加Url
            editUrl: module + '/edit', //默认的修改Url
            removeUrl: module + '/remove', //默认的删除Url
        };
        page.options = {
            module: module,
            query: query,
            toolbar: toolbar,
            formElement: formElement,
            bootstrapTable: bootstrapTable,
            config: {},// 默认的参数
            addFormAjaxOption: [],//添加表单中需要预加载的
            editFormAjaxOption: [],
            initFormOption: {
                images: [],
                dates: [],
                datetimes: [],
                times: [],
            }
        };
        $.extend(page.options.config, defaults, config);
        page.init = function () {
            LogUtil.log('开始执行自动构建页面...', 'SingleTablePageCreateUtil#createInstance->init()');

            LogUtil.log('开始创建表格页面元素(Dom)...', 'SingleTablePageCreateUtil#createInstance->init()');
            SingleTablePageCreateUtil.createSingleTableDom(module);

            LogUtil.log('开始创建搜索模块...', 'SingleTablePageCreateUtil#createInstance->init()');
            if (query && query.length != 0) {
                LogUtil.log('包含搜索模块,开始创建', 'SingleTablePageCreateUtil#createInstance->init()');
                var queryStr = '<form class="form-inline" role="form">';
                for (var i = 0; i < query.length; i++) {
                    queryStr += TablePageCreatePublicUtil.createQueryElement(query[i]);
                }
                queryStr += '<button type="submit" class="btn btn-default">查询</button></form>';
                $('#' + module + '_query').html(queryStr);
                LogUtil.log('搜索模块创建成功', 'SingleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含搜索模块,跳过', 'SingleTablePageCreateUtil#createInstance->init()');
            }

            LogUtil.log('开始创建工具条模块...', 'SingleTablePageCreateUtil#createInstance->init()');
            var firstToolBar = [];
            if (toolbar) { // 主模块
                LogUtil.log('包含工具条模块,开始执行', 'SingleTablePageCreateUtil#createInstance->init()');
                if (toolbar.default[0]) { // 默认的返回上一页模块
                    LogUtil.log('默认返回上一页模块开启-->开始生成工具栏返回按钮', 'SingleTablePageCreateUtil#createInstance->init()');
                    var backToolBar = {
                        name: '',
                        glyphicon: 'chevron-left',
                        onclick: "window.history.go(-1)"
                    };
                    firstToolBar.push(backToolBar);
                    LogUtil.log('创建默认返回上一页模块结束!', 'SingleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认返回上一页模块', 'SingleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar.default[1]) { // 默认的add模块
                    LogUtil.log('默认增加模块开启-->开始生成工具栏添加按钮', 'SingleTablePageCreateUtil#createInstance->init()');
                    var addToolBar = {
                        name: '添加',
                        glyphicon: 'plus',
                        onclick: module + '.addUI'
                    };
                    firstToolBar.push(addToolBar);
                    LogUtil.log('自动创建增加模块结束!', 'SingleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认增加模块', 'SingleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar.default[2]) {
                    LogUtil.log('默认修改模块开启-->生成工具栏修改按钮', 'SingleTablePageCreateUtil#createInstance->init()');
                    var editToolBar = {
                        name: '修改',
                        glyphicon: 'edit',
                        onclick: module + '.editUI'
                    };
                    firstToolBar.push(editToolBar);
                    LogUtil.log('自动创建修改模块结束!', 'SingleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认修改模块', 'SingleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar.default[3]) {
                    LogUtil.log('默认删除模块开启->生成工具栏删除按钮', 'SingleTablePageCreateUtil#createInstance->init()');
                    var removeToolBar = {
                        name: '删除',
                        glyphicon: 'remove',
                        onclick: module + '.removeUI'
                    };
                    LogUtil.log('工具栏删除按钮处理完毕', 'SingleTablePageCreateUtil#createInstance->init()');
                    firstToolBar.push(removeToolBar);
                } else {
                    LogUtil.log('不包含默认删除模块', 'SingleTablePageCreateUtil#createInstance->init()');
                }

                LogUtil.log('开始创建额外的工具栏...', 'SingleTablePageCreateUtil#createInstance->init()');
                var firstExtraToolBar = toolbar.extra;
                if (firstExtraToolBar) {
                    LogUtil.log('包含额外的工具栏,开始执行', 'SingleTablePageCreateUtil#createInstance->init()');
                    for (var i = 0; i < firstExtraToolBar.length; i++) {
                        firstExtraToolBar[i].onclick = module + '.' + firstExtraToolBar[i].onclick;
                    }
                    firstToolBar = firstToolBar.concat(firstExtraToolBar);
                } else {
                    LogUtil.log('不包含额外的工具栏,跳过', 'SingleTablePageCreateUtil#createInstance->init()');
                }

                if (firstToolBar && firstToolBar.length > 0) {
                    LogUtil.log('工具栏存在,正在生成按钮组...', 'SingleTablePageCreateUtil#createInstance->init()');
                    TablePageCreatePublicUtil.createToolBar(firstToolBar, module);
                } else {
                    LogUtil.log('工具栏不存在,跳过', 'SingleTablePageCreateUtil#createInstance->init()');
                }
            } else {
                LogUtil.log('不包含工具条模块,跳过', 'SingleTablePageCreateUtil#createInstance->init()');
            }

            LogUtil.log('工具栏添加按钮处理完毕-->开始处理添加/修改模态框', 'SingleTablePageCreateUtil#createInstance->init()');
            if (formElement != null && formElement.length > 0) {
                LogUtil.log('包含添加/修改模态框,开始创建', 'SingleTablePageCreateUtil#createInstance->init()');
                var addModalStr = '<div class="modal fade" data-backdrop="static" id="' +
                    module + '_modal_add"><div class="modal-dialog" style="width:' +
                    toolbar.dialog[0] + '%"><div class="modal-content"><div class="modal-header"><button class="close" data-dismiss="modal"><span>&times;</span></button><h4 class="modal-title"><b>添加对话框</b></h4></div><div class="modal-body"><form id="' +
                    module + '_form_add" class="form-horizontal" role="form">';

                var editModalStr = '<div class="modal fade" data-backdrop="static" id="' +
                    module + '_modal_edit"><div class="modal-dialog" style="width:' +
                    toolbar.dialog[0] + '%"><div class="modal-content"><div class="modal-header"><button class="close" data-dismiss="modal"><span>&times;</span></button><h4 class="modal-title"><b>修改对话框</b></h4></div><div class="modal-body"><form id="' +
                    module + '_form_edit" class="form-horizontal"  role="form">';

                for (var i = 0; i < formElement.length; i++) {
                    if (formElement[i].action[0]) { // 该元素需要添加到添加模态框
                        if (formElement[i].type === 'images') { // 类型为images,需要初始化
                            page.options.initFormOption.images.push({
                                id: module + '_form_add_' + formElement[i].id,
                                maxCount: formElement[i].maxCount || 5,
                                module: formElement[i].module || module,
                            });
                        }
                        if (formElement[i].type === 'date') { // 类型为date,需要初始化
                            page.options.initFormOption.dates.push({
                                id: module + '_form_add_' + formElement[i].id
                            });
                        }
                        if (formElement[i].type === 'datetime') { // 类型为datetime,需要初始化
                            page.options.initFormOption.datetimes.push({
                                id: module + '_form_add_' + formElement[i].id
                            });
                        }
                        if (formElement[i].type === 'time') { // 类型为time,需要初始化
                            page.options.initFormOption.times.push({
                                id: module + '_form_add_' + formElement[i].id
                            });
                        }
                        if (formElement[i].items && typeof formElement[i].items === 'string') { // items存在且为string(url),则将该任务添加到任务列表中
                            page.options.addFormAjaxOption.push({
                                id: module + '_form_add_' + formElement[i].id,
                                url: formElement[i].items
                            });
                        }
                        addModalStr += TablePageCreatePublicUtil.createFormElement(formElement[i], toolbar.dialog[1], toolbar.dialog[2], module + '_form_add_');
                    }
                    if (formElement[i].action[1]) { // 该元素需要添加到修改模态框
                        if (formElement[i].type === 'images') { // 类型为images,需要初始化
                            page.options.initFormOption.images.push({
                                id: module + '_form_edit_' + formElement[i].id,
                                maxCount: formElement[i].maxCount || 5,
                                module: formElement[i].module || module,
                            });
                        }
                        if (formElement[i].type === 'date') { // 类型为date,需要初始化
                            page.options.initFormOption.dates.push({
                                id: module + '_form_edit_' + formElement[i].id
                            });
                        }
                        if (formElement[i].type === 'datetime') { // 类型为datetime,需要初始化
                            page.options.initFormOption.datetimes.push({
                                id: module + '_form_edit_' + formElement[i].id
                            });
                        }
                        if (formElement[i].type === 'time') { // 类型为time,需要初始化
                            page.options.initFormOption.times.push({
                                id: module + '_form_edit_' + formElement[i].id
                            });
                        }
                        if (formElement[i].items && typeof formElement[i].items === 'string') { // items存在且为string(url),则将该任务添加到任务列表中
                            page.options.editFormAjaxOption.push({
                                id: module + '_form_edit_' + formElement[i].id,
                                url: formElement[i].items
                            });
                        }
                        editModalStr += TablePageCreatePublicUtil.createFormElement(formElement[i], toolbar.dialog[1], toolbar.dialog[2], module + '_form_edit_');
                    }
                }
                addModalStr += '</form></div><div class="modal-footer"><button class="btn btn-default" data-dismiss="modal">取消</button><button class="btn btn-primary" onclick="' + module + '.add()">保存</button></div></div></div></div>';
                editModalStr += '</form></div><div class="modal-footer"><button class="btn btn-default" data-dismiss="modal">取消</button><button class="btn btn-primary" onclick="' + module + '.edit()">保存</button></div></div></div></div>';
                $('body').append(addModalStr);
                $('body').append(editModalStr);
                LogUtil.log('创建添加/修改模态框成功', 'SingleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含添加/修改模态框,跳过', 'SingleTablePageCreateUtil#createInstance->init()');

            }

            //处理bootstrapTable模块
            if (!bootstrapTable.url) { // 没有url参数,使用默认
                LogUtil.log('bootstrapTable没有url参数,使用默认的url', 'SingleTablePageCreateUtil#createInstance->init()');
                bootstrapTable.url = BaseConfig.preUrl + page.options.config.listUrl + '?token=' + BaseConfig.token;
            }
            $('#' + module + '_table').bootstrapTable({
                url: bootstrapTable.url,
                responseHandler: function (resp) {
                    resp = AjaxUtil.preDeal(resp);
                    if (resp) {
                        return resp.obj;
                    } else {
                        return [];
                    }
                },
                method: 'get', // 请求方式（*）
                toolbar: '#' + module + '_toolbar', // 工具按钮用哪个容器
                striped: true, // 是否显示行间隔色,默认为false
                cache: false, // 是否使用缓存，默认为true，所以一般情况下需要设置一下这个属性（*）
                pagination: true, // 是否显示分页（*）
                sidePagination: "client", // 分页方式：client客户端分页，server服务端分页（*）
                pageNumber: 1, // 初始化加载第一页，默认第一页
                pageSize: 10, // 每页的记录行数（*）
                pageList: [10, 25, 50, 100], // 可供选择的每页的行数（*）
                search: true, // 是否显示表格搜索，此搜索是客户端搜索，不会进服务端
                showColumns: true, // 是否显示内容列下拉框
                showRefresh: true, // 是否显示刷新按钮
                clickToSelect: true, // 是否启用点击选中行
                smartDisplay: true, // 智能显示分页按钮
                columns: bootstrapTable.columns,
                onClickRow: bootstrapTable.onClickRow,
            });
            LogUtil.log('初始化表格成功,开始初始化图片上传控件', 'SingleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.images && page.options.initFormOption.images.length > 0) { // 包含需要初始化的图片上传控件
                for (var i = 0; i < page.options.initFormOption.images.length; i++) {
                    FileinputUtil.initImagesUpload('#' + page.options.initFormOption.images[i].id, page.options.initFormOption.images[i].module, page.options.initFormOption.images[i].maxCount);
                }
                LogUtil.log('初始化图片上传控件成功!', 'SingleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含图片上传控件,跳过!', 'SingleTablePageCreateUtil#createInstance->init()');
            }
            LogUtil.log('开始初始化日期选择控件', 'SingleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.dates && page.options.initFormOption.dates.length > 0) {
                for (var i = 0; i < page.options.initFormOption.dates.length; i++) {
                    $('#' + page.options.initFormOption.dates[i].id).datetimepicker({
                        language: 'zh-CN',
                        format: 'yyyy-mm-dd',
                        minView: 2,
                        autoclose: true
                    });
                }
                LogUtil.log('初始化日期选择控件成功!', 'SingleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含日期选择控件,跳过!', 'SingleTablePageCreateUtil#createInstance->init()');
            }
            LogUtil.log('开始初始化日期时间选择控件', 'SingleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.datetimes && page.options.initFormOption.datetimes.length > 0) {
                for (var i = 0; i < page.options.initFormOption.datetimes.length; i++) {
                    $('#' + page.options.initFormOption.datetimes[i].id).datetimepicker({
                        language: 'zh-CN',
                        format: 'yyyy-mm-dd hh:ii',
                        minView: 0,
                        minuteStep: 1,
                        autoclose: true
                    });
                }
                LogUtil.log('初始化日期时间选择控件成功!', 'SingleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含日期时间选择控件,跳过!', 'SingleTablePageCreateUtil#createInstance->init()');
            }
            LogUtil.log('开始初始化时间选择控件', 'SingleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.times && page.options.initFormOption.times.length > 0) {
                for (var i = 0; i < page.options.initFormOption.times.length; i++) {
                    $('#' + page.options.initFormOption.times[i].id).datetimepicker({
                        language: 'zh-CN',
                        format: 'hh:ii',
                        startView: 1,
                        minView: 0,
                        minuteStep: 1,
                        autoclose: true
                    });
                }
                LogUtil.log('初始化时间选择控件成功!', 'SingleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含时间选择控件,跳过!', 'SingleTablePageCreateUtil#createInstance->init()');
            }
        };
        page.onAddModalShowBefore = function () {
            LogUtil.log('执行打开添加模态框之前的默认回调函数', 'page#onAddModalShowBefore()');
            return true;
        };
        page.addUI = function () {
            LogUtil.log('用户点击添加按钮', 'page#addUI()');
            if (page.options.addFormAjaxOption && page.options.addFormAjaxOption.length > 0) { // 包含需要预加载的options
                for (var i = 0; i < page.options.addFormAjaxOption.length; i++) {
                    var optionStr = '<option value = "0">请点击下拉框选择</option>';
                    optionStr += TablePageCreatePublicUtil.getAjaxOptionItems(page.options.addFormAjaxOption[i].url)
                    $('#' + page.options.addFormAjaxOption[i].id).html(optionStr);
                }
            }
            if (!page.onAddModalShowBefore()) {
                return false;
            }
            $('#' + module + '_modal_add').modal('show');
        };
        page.onAddFormSubmitBefore = function (model) {
            LogUtil.log('执行提交添加表单之前的默认回调函数', 'page#onAddFormSubmitBefore()');
            if (!model) { // 用于解决空对象提交时直接结束提交的问题
                return true;
            }
            return model;
        };
        page.add = function () {
            LogUtil.log('用户点击添加保存按钮', 'page#add()');
            var model = TablePageCreatePublicUtil.serializeFilterEmptyValue($('#' + module + '_form_add').serializeArray());
            model = page.onAddFormSubmitBefore(model);
            if (!model) {
                LogUtil.log('在提交表单之前的回调函数中返回false,表单提交终止', 'page#add()');
                return false;
            }
            LogUtil.log('添加表单的内容->' + model, 'SingleTablePageCreateUtil#add()');
            var resp = AjaxUtil.postJson(page.options.config.addUrl, model);
            if (resp) {
                SwalUtil.success(resp.msg);
                $('#' + module + '_table').bootstrapTable('refresh');
                $('#' + module + '_form_add')[0].reset();
                $('#' + module + '_modal_add').modal('hide');
            }
        };
        page.onEditModalShowBefore = function (row) {
            LogUtil.log('执行打开修改模态框之前的默认回调函数', 'page#onModalAddShowBefore()');
            return row;
        };
        page.editUI = function () {
            LogUtil.log('用户点击修改按钮', 'page#editUI()');
            var row = TablePageCreatePublicUtil.getRowFromTable('#' + module + '_table', '请选择要修改的记录!', '一次只能修改一条记录!');
            if (!row) return false;
            if (page.options.editFormAjaxOption && page.options.editFormAjaxOption.length > 0) { // 包含需要预加载的options
                for (var i = 0; i < page.options.editFormAjaxOption.length; i++) {
                    var optionStr = '<option value = "0">请点击下拉框选择</option>';
                    optionStr += TablePageCreatePublicUtil.getAjaxOptionItems(page.options.editFormAjaxOption[i].url)
                    $('#' + page.options.editFormAjaxOption[i].id).html(optionStr);
                }
            }
            row = page.onEditModalShowBefore(row);
            if (!row) return false;
            $('#' + module + '_form_edit').autofill(row);
            $('#' + module + '_modal_edit').modal('show');
        };
        page.onEditFormSubmitBefore = function (model) {
            LogUtil.log('执行提交修改表单之前的默认回调函数', 'page#onEditFormSubmitBefore()');
            if (!model) { // 用于解决空对象提交时直接结束提交的问题
                return true;
            }
            return model;
        };
        page.edit = function () {
            LogUtil.log('用户点击修改保存按钮', 'page#edit()');
            var model = TablePageCreatePublicUtil.serializeFilterEmptyValue($('#' + module + '_form_edit').serializeArray());
            model = page.onEditFormSubmitBefore(model);
            if (!model) {
                LogUtil.log('在提交表单之前的回调函数中返回false,表单提交终止', 'page#edit()');
                return false;
            }
            LogUtil.log('修改后的表单的内容->' + model, 'page#edit()');
            var resp = AjaxUtil.postJson(page.options.config.editUrl, model);
            if (resp) {
                SwalUtil.success(resp.msg);
                $('#' + module + '_table').bootstrapTable('refresh');
                $('#' + module + '_form_edit')[0].reset();
                $('#' + module + '_modal_edit').modal('hide');
            }
        };
        page.onRemoveSubmitBefore = function (row) {
            LogUtil.log('执行提交删除记录之前的默认回调函数', 'page#onRemoveSubmitBefore()');
            return row;
        };
        page.removeUI = function () {
            LogUtil.log('用户点击删除按钮', 'page#removeUI()');
            var row = TablePageCreatePublicUtil.getRowFromTable('#' + module + '_table', '请选择要删除的记录!', '一次只能删除一条记录!');
            if (!row) return false;
            row = page.onRemoveSubmitBefore(row);
            if (!row) return false;
            SwalUtil.confirm(function () {
                LogUtil.log('确定删除记录->' + row, 'page#remove()');
                var resp = AjaxUtil.postJson(page.options.config.removeUrl, row);
                if (resp) {
                    SwalUtil.success(resp.msg);
                    $('#' + module + '_table').bootstrapTable('refresh');
                }
            });
        };
        page.init();
        LogUtil.log('创建单表格页面成功!!!', 'SingleTablePageCreateUtil#createInstanceSingleTablePage->init()');
        return page;
    },

    // 私有方法,不需要暴露//////////////////////////////////////////////////////////////////
    createSingleTableDom: function (module) { // 生成表格Dom节点
        var tableStr = '<div style="margin-top:10px" class="panel panel-default"><div id="' + module + '_query" style="padding-bottom : 0px" class="panel-body"></div><div class="panel-body"><table id="' + module + '_table"></table></div></div>';
        $('body').append(tableStr);
        LogUtil.log('创建表格页面元素(Dom)成功!', 'SingleTablePageCreateUtil#initial() -> createSingleTableDom()');
    },
}

/**
 * 创建双表格的页面
 * * @param module
 * @param query
 * @param toolbar
 * @param formElementLeft
 * @param formElementRight
 * @param bootstrapTableLeft
 * @param bootstrapTableRight
 */
DoubleTablePageCreateUtil = {
    createInstance: function (module, query, toolbar, formElementLeft, formElementRight, bootstrapTableLeft, bootstrapTableRight, config) {
        var page = {};
        var defaults = {
            listUrlLeft: module[0] + '/list', // 默认的左边列表Url
            addUrlLeft: module[0] + '/add', // 默认的左边添加Url
            editUrlLeft: module[0] + '/edit', //默认的左边修改Url
            removeUrlLeft: module[0] + '/remove', //默认的左边删除Url
            listUrlRight: module[2] + '/list', // 默认的左边列表Url
            addUrlRight: module[2] + '/add', // 默认的右边添加Url
            editUrlRight: module[2] + '/edit',//默认的右边修改Url
            removeUrlRight: module[2] + '/remove',//默认的右边删除Url
        };
        page.options = {
            module: module,
            query: query,
            toolbar: toolbar,
            formElementLeft: formElementLeft,
            formElementRight: formElementRight,
            bootstrapTableLeft: bootstrapTableLeft,
            bootstrapTableRight: bootstrapTableRight,
            config: {},// 默认的参数
            addFormAjaxOptionLeft: [],//左边添加表单中需要预加载的
            addFormAjaxOptionRight: [],//右边添加表单中需要预加载的
            editFormAjaxOptionLeft: [],
            editFormAjaxOptionRight: [],
            initFormOption: {
                images: [],
                dates: [],
                datetimes: []
            }
        };
        $.extend(page.options.config, defaults, config);
        page.init = function () {
            LogUtil.log('开始执行自动构建页面...', 'DoubleTablePageCreateUtil#createInstance->init()');

            LogUtil.log('开始创建表格页面元素(Dom)...', 'DoubleTablePageCreateUtil#createInstance->init()');
            DoubleTablePageCreateUtil.createDoubleTableDom(module);

            LogUtil.log('开始创建搜索模块...', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (query && query.length != 0) {
                LogUtil.log('包含搜索模块,开始创建', 'DoubleTablePageCreateUtil#createInstance->init()');
                var queryStr = '<form class="form-inline" role="form">';
                for (var i = 0; i < query.length; i++) {
                    queryStr += TablePageCreatePublicUtil.createQueryElement(query[i]);
                }
                queryStr += '<button  onclick="' + module[0] + '.query();return false;"  class="btn btn-default">查询</button></form>';
                $('#' + module[0] + '_query').html(queryStr);
                LogUtil.log('搜索模块创建成功', 'DoubleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含搜索模块,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
            }

            LogUtil.log('开始创建左边工具条模块...', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (toolbar && toolbar[0]) { // 左边工具条
                var leftToolBar = [];
                LogUtil.log('包含左边工具条模块,开始执行', 'DoubleTablePageCreateUtil#createInstance->init()');
                if (toolbar[0].default[0]) { // 默认的返回上一页模块
                    LogUtil.log('默认返回上一页模块开启-->开始生成左边工具栏返回按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var backToolBar = {
                        name: '',
                        glyphicon: 'chevron-left',
                        onclick: "window.history.go(-1)"
                    };
                    leftToolBar.push(backToolBar);
                    LogUtil.log('创建默认返回上一页模块结束!', 'DoubleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认返回上一页模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar[0].default[1]) { // 默认的add模块
                    LogUtil.log('默认增加模块开启-->开始生成左边工具栏添加按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var addToolBar = {
                        name: '添加',
                        glyphicon: 'plus',
                        onclick: module[0] + '.addUI'
                    };
                    leftToolBar.push(addToolBar);
                    LogUtil.log('自动创建增加模块结束!', 'DoubleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认增加模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar[0].default[2]) {
                    LogUtil.log('默认修改模块开启-->生成左边工具栏修改按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var editToolBar = {
                        name: '修改',
                        glyphicon: 'edit',
                        onclick: module[0] + '.editUI'
                    };
                    leftToolBar.push(editToolBar);
                    LogUtil.log('自动创建修改模块结束!', 'DoubleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认修改模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar[0].default[3]) {
                    LogUtil.log('默认删除模块开启->生成左边工具栏删除按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var removeToolBar = {
                        name: '删除',
                        glyphicon: 'remove',
                        onclick: module[0] + '.removeUI'
                    };
                    LogUtil.log('工具栏删除按钮处理完毕', 'DoubleTablePageCreateUtil#createInstance->init()');
                    leftToolBar.push(removeToolBar);
                } else {
                    LogUtil.log('不包含默认删除模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }

                LogUtil.log('开始创建额外的左边工具栏...', 'DoubleTablePageCreateUtil#createInstance->init()');
                var leftExtraToolBar = toolbar[0].extra;
                if (leftExtraToolBar) {
                    LogUtil.log('包含额外的左边工具栏,开始执行', 'DoubleTablePageCreateUtil#createInstance->init()');
                    for (var i = 0; i < leftExtraToolBar.length; i++) {
                        leftExtraToolBar[i].onclick = module[0] + '.' + leftExtraToolBar[i].onclick;
                    }
                    leftToolBar = leftToolBar.concat(leftExtraToolBar);
                } else {
                    LogUtil.log('不包含额外的左边工具栏,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
                }

                if (leftToolBar && leftToolBar.length > 0) {
                    LogUtil.log('左边工具栏存在,正在生成按钮组...', 'DoubleTablePageCreateUtil#createInstance->init()');
                    TablePageCreatePublicUtil.createToolBar(leftToolBar, module[0]);
                } else {
                    LogUtil.log('左边工具栏不存在,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
            } else {
                LogUtil.log('不包含左边工具条模块,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
            }
            LogUtil.log('开始创建右边工具条模块...', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (toolbar && toolbar[1]) { // 右边工具条
                var rightToolBar = [];
                LogUtil.log('包含工具条模块,开始执行', 'DoubleTablePageCreateUtil#createInstance->init()');
                if (toolbar[1].default[0]) { // 默认的返回上一页模块
                    LogUtil.log('默认返回上一页模块开启-->开始生成右边工具栏返回按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var backToolBar = {
                        name: '',
                        glyphicon: 'chevron-left',
                        onclick: "window.history.go(-1)"
                    };
                    rightToolBar.push(backToolBar);
                    LogUtil.log('创建默认返回上一页模块结束!', 'DoubleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认返回上一页模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar[1].default[1]) { // 默认的add模块
                    LogUtil.log('默认增加模块开启-->开始生成右边工具栏添加按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var addToolBar = {
                        name: '添加',
                        glyphicon: 'plus',
                        onclick: module[0] + '.second.addUI'
                    };
                    rightToolBar.push(addToolBar);
                    LogUtil.log('自动创建增加模块结束!', 'DoubleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认增加模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar[1].default[2]) {
                    LogUtil.log('默认修改模块开启-->生成右边工具栏修改按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var editToolBar = {
                        name: '修改',
                        glyphicon: 'edit',
                        onclick: module[0] + '.second.editUI'
                    };
                    rightToolBar.push(editToolBar);
                    LogUtil.log('自动创建修改模块结束!', 'DoubleTablePageCreateUtil#createInstance->init()');
                } else {
                    LogUtil.log('不包含默认修改模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
                if (toolbar[1].default[3]) {
                    LogUtil.log('默认删除模块开启->生成右边工具栏删除按钮', 'DoubleTablePageCreateUtil#createInstance->init()');
                    var removeToolBar = {
                        name: '删除',
                        glyphicon: 'remove',
                        onclick: module[0] + '.second.removeUI'
                    };
                    LogUtil.log('工具栏删除按钮处理完毕', 'DoubleTablePageCreateUtil#createInstance->init()');
                    rightToolBar.push(removeToolBar);
                } else {
                    LogUtil.log('不包含默认删除模块', 'DoubleTablePageCreateUtil#createInstance->init()');
                }

                LogUtil.log('开始创建额外的右边工具栏...', 'DoubleTablePageCreateUtil#createInstance->init()');
                var rightExtraToolBar = toolbar[1].extra;
                if (rightExtraToolBar) {
                    LogUtil.log('包含额外的右边工具栏,开始执行', 'DoubleTablePageCreateUtil#createInstance->init()');
                    for (var i = 0; i < rightExtraToolBar.length; i++) {
                        rightExtraToolBar[i].onclick = module[0] + '.second.' + rightExtraToolBar[i].onclick;
                    }
                    rightToolBar = rightToolBar.concat(rightExtraToolBar);
                } else {
                    LogUtil.log('不包含额外的右边工具栏,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
                }

                if (rightToolBar && rightToolBar.length > 0) {
                    LogUtil.log('右边工具栏存在,正在生成按钮组...', 'DoubleTablePageCreateUtil#createInstance->init()');
                    TablePageCreatePublicUtil.createToolBar(rightToolBar, module[2]);
                } else {
                    LogUtil.log('右边工具栏不存在,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
                }
            } else {
                LogUtil.log('不包含左边工具条模块,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
            }

            LogUtil.log('工具栏添加按钮处理完毕-->开始处理添加/修改左边模态框', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (formElementLeft && formElementLeft.length > 0) {
                LogUtil.log('包含添加/修改左边模态框,开始创建', 'DoubleTablePageCreateUtil#createInstance->init()');
                var addModalStr = '<div class="modal fade" data-backdrop="static" id="' +
                    module[0] + '_modal_add"><div class="modal-dialog" style="width:' +
                    toolbar[0].dialog[0] + '%"><div class="modal-content"><div class="modal-header"><button class="close" data-dismiss="modal"><span>&times;</span></button><h4 class="modal-title"><b>添加对话框</b></h4></div><div class="modal-body"><form id="' +
                    module[0] + '_form_add" class="form-horizontal" role="form">';

                var editModalStr = '<div class="modal fade" data-backdrop="static" id="' +
                    module[0] + '_modal_edit"><div class="modal-dialog" style="width:' +
                    toolbar[0].dialog[0] + '%"><div class="modal-content"><div class="modal-header"><button class="close" data-dismiss="modal"><span>&times;</span></button><h4 class="modal-title"><b>修改对话框</b></h4></div><div class="modal-body"><form id="' +
                    module[0] + '_form_edit" class="form-horizontal"  role="form">';

                for (var i = 0; i < formElementLeft.length; i++) {
                    if (formElementLeft[i].action[0]) { // 该元素需要添加到添加模态框
                        if (formElementLeft[i].type === 'images') { // 类型为images,需要初始化
                            page.options.initFormOption.images.push({
                                id: module[0] + '_form_add_' + formElementLeft[i].id,
                                maxCount: formElementLeft[i].maxCount || 5,
                                module: formElementLeft[i].module || module,
                            });
                        }
                        if (formElementLeft[i].type === 'date') { // 类型为date,需要初始化
                            page.options.initFormOption.dates.push({
                                id: module[0] + '_form_add_' + formElementLeft[i].id
                            });
                        }
                        if (formElementLeft[i].type === 'datetime') { // 类型为datetime,需要初始化
                            page.options.initFormOption.datetimes.push({
                                id: module[0] + '_form_add_' + formElementLeft[i].id
                            });
                        }
                        if (formElementLeft[i].type === 'time') { // 类型为time,需要初始化
                            page.options.initFormOption.times.push({
                                id: module[0] + '_form_add_' + formElementLeft[i].id
                            });
                        }
                        if (formElementLeft[i].items && typeof formElementLeft[i].items === 'string') { // items存在且为string(url),则将该任务添加到任务列表中
                            page.options.addFormAjaxOptionLeft.push({
                                id: module[0] + '_form_add_' + formElementLeft[i].id,
                                url: formElementLeft[i].items
                            });
                        }
                        addModalStr += TablePageCreatePublicUtil.createFormElement(formElementLeft[i], toolbar[0].dialog[1], toolbar[0].dialog[2], module[0] + '_form_add_');
                    }
                    if (formElementLeft[i].action[1]) { // 该元素需要添加到修改模态框
                        if (formElementLeft[i].type === 'images') { // 类型为images,需要初始化
                            page.options.initFormOption.images.push({
                                id: module[0] + '_form_edit_' + formElementLeft[i].id,
                                maxCount: formElementLeft[i].maxCount || 5,
                                module: formElementLeft[i].module || module,
                            });
                        }
                        if (formElementLeft[i].type === 'date') { // 类型为date,需要初始化
                            page.options.initFormOption.dates.push({
                                id: module[0] + '_form_edit_' + formElementLeft[i].id
                            });
                        }
                        if (formElementLeft[i].type === 'datetime') { // 类型为datetime,需要初始化
                            page.options.initFormOption.datetimes.push({
                                id: module[0] + '_form_edit_' + formElementLeft[i].id
                            });
                        }
                        if (formElementLeft[i].type === 'time') { // 类型为datetime,需要初始化
                            page.options.initFormOption.times.push({
                                id: module[0] + '_form_edit_' + formElementLeft[i].id
                            });
                        }
                        if (formElementLeft[i].items && typeof formElementLeft[i].items === 'string') { // items存在且为string(url),则将该任务添加到任务列表中
                            page.options.editFormAjaxOptionLeft.push({
                                id: module[0] + '_form_edit_' + formElementLeft[i].id,
                                url: formElementLeft[i].items
                            });
                        }
                        editModalStr += TablePageCreatePublicUtil.createFormElement(formElementLeft[i], toolbar[0].dialog[1], toolbar[0].dialog[2], module[0] + '_form_edit_');
                    }
                }
                addModalStr += '</form></div><div class="modal-footer"><button class="btn btn-default" data-dismiss="modal">取消</button><button class="btn btn-primary" onclick="' + module[0] + '.add()">保存</button></div></div></div></div>';
                editModalStr += '</form></div><div class="modal-footer"><button class="btn btn-default" data-dismiss="modal">取消</button><button class="btn btn-primary" onclick="' + module[0] + '.edit()">保存</button></div></div></div></div>';
                $('body').append(addModalStr);
                $('body').append(editModalStr);
                LogUtil.log('创建添加/修改右边模态框成功', 'DoubleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含添加/修改右边模态框,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
            }
            if (formElementRight && formElementRight.length > 0) {
                LogUtil.log('包含添加/修改右边模态框,开始创建', 'DoubleTablePageCreateUtil#createInstance->init()');
                var addModalStr = '<div class="modal fade" data-backdrop="static" id="' +
                    module[2] + '_modal_add"><div class="modal-dialog" style="width:' +
                    toolbar[1].dialog[0] + '%"><div class="modal-content"><div class="modal-header"><button class="close" data-dismiss="modal"><span>&times;</span></button><h4 class="modal-title"><b>添加对话框</b></h4></div><div class="modal-body"><form id="' +
                    module[2] + '_form_add" class="form-horizontal" role="form">';

                var editModalStr = '<div class="modal fade" data-backdrop="static" id="' +
                    module[2] + '_modal_edit"><div class="modal-dialog" style="width:' +
                    toolbar[1].dialog[0] + '%"><div class="modal-content"><div class="modal-header"><button class="close" data-dismiss="modal"><span>&times;</span></button><h4 class="modal-title"><b>修改对话框</b></h4></div><div class="modal-body"><form id="' +
                    module[2] + '_form_edit" class="form-horizontal"  role="form">';

                for (var i = 0; i < formElementRight.length; i++) {
                    if (formElementRight[i].action[0]) { // 该元素需要添加到添加模态框
                        if (formElementRight[i].type === 'images') { // 类型为images,需要初始化
                            page.options.initFormOption.images.push({
                                id: module[2] + '_form_add_' + formElementRight[i].id,
                                maxCount: formElementRight[i].maxCount || 5,
                                module: formElementRight[i].module || module,
                            });
                        }
                        if (formElementRight[i].type === 'date') { // 类型为images,需要初始化
                            page.options.initFormOption.dates.push({
                                id: module[2] + '_form_add_' + formElementRight[i].id
                            });
                        }
                        if (formElementRight[i].type === 'datetime') { // 类型为datetime,需要初始化
                            page.options.initFormOption.datetimes.push({
                                id: module[2] + '_form_add_' + formElementRight[i].id
                            });
                        }
                        if (formElementRight[i].type === 'time') { // 类型为time,需要初始化
                            page.options.initFormOption.times.push({
                                id: module[2] + '_form_add_' + formElementRight[i].id
                            });
                        }
                        if (formElementRight[i].items && typeof formElementRight[i].items === 'string') { // items存在且为string(url),则将该任务添加到任务列表中
                            page.options.addFormAjaxOptionRight.push({
                                id: module[2] + '_form_add_' + formElementRight[i].id,
                                url: formElementRight[i].items
                            });
                        }
                        addModalStr += TablePageCreatePublicUtil.createFormElement(formElementRight[i], toolbar[1].dialog[1], toolbar[1].dialog[2], module[2] + '_form_add_');
                    }
                    if (formElementRight[i].action[1]) { // 该元素需要添加到修改模态框
                        if (formElementRight[i].type === 'images') { // 类型为images,需要初始化
                            page.options.initFormOption.images.push({
                                id: module[2] + '_form_edit_' + formElementRight[i].id,
                                maxCount: formElementRight[i].maxCount || 5,
                                module: formElementRight[i].module || module,
                            });
                        }
                        if (formElementRight[i].type === 'date') { // 类型为images,需要初始化
                            page.options.initFormOption.dates.push({
                                id: module[2] + '_form_edit_' + formElementRight[i].id
                            });
                        }
                        if (formElementRight[i].type === 'datetime') { // 类型为datetime,需要初始化
                            page.options.initFormOption.datetimes.push({
                                id: module[2] + '_form_edit_' + formElementRight[i].id
                            });
                        }
                        if (formElementRight[i].type === 'time') { // 类型为date,需要初始化
                            page.options.initFormOption.times.push({
                                id: module[2] + '_form_edit_' + formElementRight[i].id
                            });
                        }
                        if (formElementRight[i].items && typeof formElementRight[i].items === 'string') { // items存在且为string(url),则将该任务添加到任务列表中
                            page.options.editFormAjaxOptionRight.push({
                                id: module[2] + '_form_edit_' + formElementRight[i].id,
                                url: formElementRight[i].items
                            });
                        }
                        editModalStr += TablePageCreatePublicUtil.createFormElement(formElementRight[i], toolbar[1].dialog[1], toolbar[1].dialog[2], module[2] + '_form_edit_');
                    }
                }
                addModalStr += '</form></div><div class="modal-footer"><button class="btn btn-default" data-dismiss="modal">取消</button><button class="btn btn-primary" onclick="' + module[0] + '.second.add()">保存</button></div></div></div></div>';
                editModalStr += '</form></div><div class="modal-footer"><button class="btn btn-default" data-dismiss="modal">取消</button><button class="btn btn-primary" onclick="' + module[0] + '.second.edit()">保存</button></div></div></div></div>';
                $('body').append(addModalStr);
                $('body').append(editModalStr);
                LogUtil.log('创建添加/修改右边模态框成功', 'DoubleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含添加/修改右边模态框,跳过', 'DoubleTablePageCreateUtil#createInstance->init()');
            }

            // 处理bootstrapTable模块
            $('#' + module[0] + '_table').bootstrapTable({
                url: BaseConfig.preUrl + page.options.config.listUrlLeft + '?token=' + BaseConfig.token, // 请求后台的URL（*）
                responseHandler: function (resp) {
                    resp = AjaxUtil.preDeal(resp);
                    if (resp) {
                        return resp.obj;
                    } else {
                        return [];
                    }
                },
                method: 'get', // 请求方式（*）
                toolbar: '#' + module[0] + '_toolbar', // 工具按钮用哪个容器
                striped: true, // 是否显示行间隔色,默认为false
                cache: false, // 是否使用缓存，默认为true，所以一般情况下需要设置一下这个属性（*）
                pagination: true, // 是否显示分页（*）
                sidePagination: "client", // 分页方式：client客户端分页，server服务端分页（*）
                pageNumber: 1, // 初始化加载第一页，默认第一页
                pageSize: 10, // 每页的记录行数（*）
                pageList: [10, 25, 50, 100], // 可供选择的每页的行数（*）
                search: true, // 是否显示表格搜索，此搜索是客户端搜索，不会进服务端
                showColumns: true, // 是否显示内容列下拉框
                showRefresh: true, // 是否显示刷新按钮
                clickToSelect: true, // 是否启用点击选中行
                smartDisplay: true, // 智能显示分页按钮
                columns: bootstrapTableLeft.columns,
                onClickRow: bootstrapTableLeft.onClickRow,
            });
            LogUtil.log('初始化左边表格结束', 'DoubleTablePageCreateUtil#createInstance->init()');


            $('#' + module[2] + '_table').bootstrapTable({
                url: BaseConfig.preUrl + page.options.config.listUrlRight + '?token=' + BaseConfig.token, // 请求后台的URL（*）
                responseHandler: function (resp) {
                    resp = AjaxUtil.preDeal(resp);
                    if (resp) {
                        return resp.obj;
                    } else {
                        return [];
                    }
                },
                method: 'get', // 请求方式（*）
                toolbar: '#' + module[2] + '_toolbar', // 工具按钮用哪个容器
                striped: true, // 是否显示行间隔色,默认为false
                cache: false, // 是否使用缓存，默认为true，所以一般情况下需要设置一下这个属性（*）
                pagination: true, // 是否显示分页（*）
                sidePagination: "client", // 分页方式：client客户端分页，server服务端分页（*）
                pageNumber: 1, // 初始化加载第一页，默认第一页
                pageSize: 10, // 每页的记录行数（*）
                pageList: [10, 25, 50, 100], // 可供选择的每页的行数（*）
                search: true, // 是否显示表格搜索，此搜索是客户端搜索，不会进服务端
                showColumns: true, // 是否显示内容列下拉框
                showRefresh: true, // 是否显示刷新按钮
                clickToSelect: true, // 是否启用点击选中行
                smartDisplay: true, // 智能显示分页按钮
                columns: bootstrapTableRight.columns,
                onClickRow: bootstrapTableRight.onClickRow,
            });
            LogUtil.log('初始化右边表格成功,开始初始化图片上传控件', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.images && page.options.initFormOption.images.length > 0) { // 包含需要初始化的图片上传控件
                for (var i = 0; i < page.options.initFormOption.images.length; i++) {
                    FileinputUtil.initImagesUpload('#' + page.options.initFormOption.images[i].id, page.options.initFormOption.images[i].module, page.options.initFormOption.images[i].maxCount);
                }
                LogUtil.log('初始化图片上传控件成功!', 'DoubleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含图片上传控件,跳过!', 'DoubleTablePageCreateUtil#createInstance->init()');
            }
            LogUtil.log('开始初始化日期选择控件', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.dates && page.options.initFormOption.dates.length > 0) {
                for (var i = 0; i < page.options.initFormOption.dates.length; i++) {
                    $('#' + page.options.initFormOption.dates[i].id).datetimepicker({
                        language: 'zh-CN',
                        format: 'yyyy-mm-dd',
                        minView: 2,
                        autoclose: true
                    });
                }
                LogUtil.log('初始化日期选择控件成功!', 'DoubleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含日期选择控件,跳过!', 'DoubleTablePageCreateUtil#createInstance->init()');
            }
            LogUtil.log('开始初始化日期时间选择控件', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.datetimes && page.options.initFormOption.datetimes.length > 0) {
                for (var i = 0; i < page.options.initFormOption.datetimes.length; i++) {
                    $('#' + page.options.initFormOption.datetimes[i].id).datetimepicker({
                        language: 'zh-CN',
                        format: 'yyyy-mm-dd hh:ii',
                        minView: 0,
                        minuteStep: 1,
                        autoclose: true
                    });
                }
                LogUtil.log('初始化时间选择控件成功!', 'DoubleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含时间选择控件,跳过!', 'DoubleTablePageCreateUtil#createInstance->init()');
            }
            LogUtil.log('开始初始化时间选择控件', 'DoubleTablePageCreateUtil#createInstance->init()');
            if (page.options.initFormOption.times && page.options.initFormOption.times.length > 0) {
                for (var i = 0; i < page.options.initFormOption.times.length; i++) {
                    $('#' + page.options.initFormOption.times[i].id).datetimepicker({
                        language: 'zh-CN',
                        format: 'hh:ii',
                        startView: 1,
                        minView: 0,
                        minuteStep: 1,
                        autoclose: true
                    });
                }
                LogUtil.log('初始化时间选择控件成功!', 'DoubleTablePageCreateUtil#createInstance->init()');
            } else {
                LogUtil.log('不包含时间选择控件,跳过!', 'DoubleTablePageCreateUtil#createInstance->init()');
            }

        };
        page.onAddModalShowBefore = function () {
            LogUtil.log('执行打开添加模态框之前的默认回调函数', 'page#onAddModalShowBefore()');
            return true;
        };
        page.addUI = function () {
            LogUtil.log('用户点击添加按钮', 'page#addUI()');
            if (page.options.addFormAjaxOptionLeft && page.options.addFormAjaxOptionLeft.length > 0) { // 包含需要预加载的options
                for (var i = 0; i < page.options.addFormAjaxOptionLeft.length; i++) {
                    var optionStr = '<option value = "0">请点击下拉框选择</option>';
                    optionStr += TablePageCreatePublicUtil.getAjaxOptionItems(page.options.addFormAjaxOptionLeft[i].url)
                    $('#' + page.options.addFormAjaxOptionLeft[i].id).html(optionStr);
                }
            }
            if (!page.onAddModalShowBefore()) {
                return false;
            }
            $('#' + module[0] + '_modal_add').modal('show');
        };
        page.onAddFormSubmitBefore = function (model) {
            LogUtil.log('执行提交添加表单之前的默认回调函数', 'page#onAddFormSubmitBefore()');
            if (!model) {
                return true;
            }
            return model;
        };
        page.add = function () {
            LogUtil.log('用户点击添加保存按钮', 'page#add()');
            var model = TablePageCreatePublicUtil.serializeFilterEmptyValue($('#' + module[0] + '_form_add').serializeArray());
            model = page.onAddFormSubmitBefore(model);
            if (!model) {
                LogUtil.log('在提交表单之前的回调函数中返回false,表单提交终止', 'page#add()');
                return false;
            }
            LogUtil.log('添加表单的内容->' + model, 'page#add()');
            var resp = AjaxUtil.postJson(page.options.config.addUrlLeft, model);
            if (resp) {
                SwalUtil.success(resp.msg);
                $('#' + module[0] + '_table').bootstrapTable('refresh');
                $('#' + module[0] + '_form_add')[0].reset();
                $('#' + module[0] + '_modal_add').modal('hide');
            }
        };
        page.onEditModalShowBefore = function (row) {
            LogUtil.log('执行打开修改模态框之前的默认回调函数', 'page#onModalAddShowBefore()');
            return row;
        };
        page.editUI = function () {
            LogUtil.log('用户点击修改按钮', 'page#editUI()');
            var row = TablePageCreatePublicUtil.getRowFromTable('#' + module[0] + '_table', '请选择要修改的记录!', '一次只能修改一条记录!');
            if (!row) return false;
            if (page.options.editFormAjaxOptionLeft && page.options.editFormAjaxOptionLeft.length > 0) { // 包含需要预加载的options
                for (var i = 0; i < page.options.editFormAjaxOptionLeft.length; i++) {
                    var optionStr = '<option value = "0">请点击下拉框选择</option>';
                    optionStr += TablePageCreatePublicUtil.getAjaxOptionItems(page.options.editFormAjaxOptionLeft[i].url)
                    $('#' + page.options.editFormAjaxOptionLeft[i].id).html(optionStr);
                }
            }
            row = page.onEditModalShowBefore(row);
            if (!row) return false;
            $('#' + module[0] + '_form_edit').autofill(row);
            $('#' + module[0] + '_modal_edit').modal('show');
        };
        page.onEditFormSubmitBefore = function (model) {
            LogUtil.log('执行提交修改表单之前的默认回调函数', 'page#onEditFormSubmitBefore()');
            if (!model) {
                return true;
            }
            return model;
        };
        page.edit = function () {
            LogUtil.log('用户点击修改保存按钮', 'page#edit()');
            var model = TablePageCreatePublicUtil.serializeFilterEmptyValue($('#' + module[0] + '_form_edit').serializeArray());
            model = page.onEditFormSubmitBefore(model);
            if (!model) {
                LogUtil.log('在提交表单之前的回调函数中返回false,表单提交终止', 'page#edit()');
                return false;
            }
            LogUtil.log('修改后的表单的内容->' + model, 'page#edit()');
            var resp = AjaxUtil.postJson(page.options.config.editUrlLeft, model);
            if (resp) {
                SwalUtil.success(resp.msg);
                $('#' + module[0] + '_table').bootstrapTable('refresh');
                $('#' + module[0] + '_form_edit')[0].reset();
                $('#' + module[0] + '_modal_edit').modal('hide');
            }
        };
        page.onRemoveSubmitBefore = function (row) {
            LogUtil.log('执行提交删除记录之前的默认回调函数', 'page#onRemoveSubmitBefore()');
            return row;
        };
        page.removeUI = function () {
            LogUtil.log('用户点击删除按钮', 'page#removeUI()');
            var row = TablePageCreatePublicUtil.getRowFromTable('#' + module[0] + '_table', '请选择要删除的记录!', '一次只能删除一条记录!');
            if (!row) return false;
            row = page.onRemoveSubmitBefore(row);
            if (!row) return false;
            SwalUtil.confirm(function () {
                LogUtil.log('确定删除记录->' + row, 'page#remove()');
                var resp = AjaxUtil.postJson(page.options.config.removeUrlLeft, row);
                if (resp) {
                    SwalUtil.success(resp.msg);
                    $('#' + module[0] + '_table').bootstrapTable('refresh');
                }
            });
        };
        page.second = {};
        page.second.onAddModalShowBefore = function () {
            LogUtil.log('执行打开添加模态框之前的默认回调函数', 'page.second#onAddModalShowBefore()');
            return true;
        };
        page.second.addUI = function () {
            LogUtil.log('用户点击添加按钮', 'page.second#addUI()');
            if (page.options.addFormAjaxOptionRight && page.options.addFormAjaxOptionRight.length > 0) { // 包含需要预加载的options
                for (var i = 0; i < page.options.addFormAjaxOptionRight.length; i++) {
                    var optionStr = TablePageCreatePublicUtil.getAjaxOptionItems(page.options.addFormAjaxOptionRight[i].url)
                    $('#' + page.options.addFormAjaxOptionRight[i].id).html(optionStr);
                }
            }
            if (!page.second.onAddModalShowBefore()) {
                return false;
            }
            $('#' + module[2] + '_modal_add').modal('show');
        };
        page.second.onAddFormSubmitBefore = function (model) {
            LogUtil.log('执行提交添加表单之前的默认回调函数', 'page.second#onAddFormSubmitBefore()');
            return model;
        };
        page.second.add = function () {
            LogUtil.log('用户点击添加保存按钮', 'page.second#add()');
            var model = TablePageCreatePublicUtil.serializeFilterEmptyValue($('#' + module[2] + '_form_add').serializeArray());
            model = page.second.onAddFormSubmitBefore(model);
            if (!model) {
                LogUtil.log('在提交表单之前的回调函数中返回false,表单提交终止', 'page.second#add()');
                return false;
            }
            LogUtil.log('添加表单的内容->' + model, 'page.second#add()');
            var resp = AjaxUtil.postJson(page.options.config.addUrlRight, model);
            if (resp) {
                SwalUtil.success(resp.msg);
                $('#' + module[2] + '_table').bootstrapTable('refresh');
                $('#' + module[2] + '_form_add')[0].reset();
                $('#' + module[2] + '_modal_add').modal('hide');
            }
        };
        page.second.onEditModalShowBefore = function (row) {
            LogUtil.log('执行打开修改模态框之前的默认回调函数', 'page.second#onModalAddShowBefore()');
            return row;
        };
        page.second.editUI = function () {
            LogUtil.log('用户点击修改按钮', 'page.second.second#editUI()');
            var row = TablePageCreatePublicUtil.getRowFromTable('#' + module[2] + '_table', '请选择要修改的记录!', '一次只能修改一条记录!');
            if (!row) return false;
            if (page.options.editFormAjaxOptionRight && page.options.editFormAjaxOptionRight.length > 0) { // 包含需要预加载的options
                for (var i = 0; i < page.options.editFormAjaxOptionRight.length; i++) {
                    var optionStr = TablePageCreatePublicUtil.getAjaxOptionItems(page.options.editFormAjaxOptionRight[i].url)
                    $('#' + page.options.editFormAjaxOptionRight[i].id).html(optionStr);
                }
            }
            row = page.second.onEditModalShowBefore(row);
            if (!row) return false;
            $('#' + module[2] + '_form_edit').autofill(row);
            $('#' + module[2] + '_modal_edit').modal('show');
        };
        page.second.onEditFormSubmitBefore = function (model) {
            LogUtil.log('执行提交修改表单之前的默认回调函数', 'page.second#onEditFormSubmitBefore()');
            return model;
        };
        page.second.edit = function () {
            LogUtil.log('用户点击修改保存按钮', 'page#edit()');
            var model = TablePageCreatePublicUtil.serializeFilterEmptyValue($('#' + module[2] + '_form_edit').serializeArray());
            model = page.second.onEditFormSubmitBefore(model);
            if (!model) {
                LogUtil.log('在提交表单之前的回调函数中返回false,表单提交终止', 'page.second#edit()');
                return false;
            }
            LogUtil.log('修改后的表单的内容->' + model, 'page.second#edit()');
            var resp = AjaxUtil.postJson(page.options.config.editUrlRight, model);
            if (resp) {
                SwalUtil.success(resp.msg);
                $('#' + module[2] + '_table').bootstrapTable('refresh');
                $('#' + module[2] + '_form_edit')[0].reset();
                $('#' + module[2] + '_modal_edit').modal('hide');
            }
        };
        page.second.onRemoveSubmitBefore = function (row) {
            LogUtil.log('执行提交删除记录之前的默认回调函数', 'page.second#onRemoveSubmitBefore()');
            return row;
        };
        page.second.removeUI = function () {
            LogUtil.log('用户点击删除按钮', 'page.second#removeUI()');
            var row = TablePageCreatePublicUtil.getRowFromTable('#' + module[2] + '_table', '请选择要删除的记录!', '一次只能删除一条记录!');
            if (!row) return false;
            row = page.second.onRemoveSubmitBefore(row);
            if (!row) return false;
            SwalUtil.confirm(function () {
                LogUtil.log('确定删除记录->' + row, 'page.second#remove()');
                var resp = AjaxUtil.postJson(page.options.config.removeUrlRight, row);
                if (resp) {
                    SwalUtil.success(resp.msg);
                    $('#' + module[2] + '_table').bootstrapTable('refresh');
                }
            });
        };


        page.init();
        LogUtil.log('创建单表格页面成功!!!', 'DoubleTablePageCreateUtil#createInstanceSingleTablePage->init()');
        return page;
    },
    createDoubleTableDom: function (module) { // 生成表格Dom节点
        var tableStr = '<div class="panel panel-default"><div id="' + module[0] + '_query" style="padding-bottom : 0px" class="panel-body"></div><div class="panel-body"><div class="col-sm-' + module[1] + '"><table id="' + module[0] + '_table"></table></div><div class="col-sm-' + module[3] + '"><table id="' + module[2] + '_table"></table></div></div></div>';
        $('body').append(tableStr);
        LogUtil.log('创建表格页面元素(Dom)成功!', 'DoubleTablePageCreateUtil#createDoubleTableDom()')
    }
}
TablePageCreatePublicUtil = {
    createToolBar: function (toolbar, module) {
        var toolbarStr = '<div id="' + module + '_toolbar"><div class="btn-group">'
        for (var i = 0; i < toolbar.length; i++) {
            var onclick = toolbar[i].onclick + '()';
            var icon = 'asterisk';
            if (toolbar[i].glyphicon) {
                icon = toolbar[i].glyphicon;
            }
            toolbarStr += '<button type="button" class="btn btn-default" onclick="' + onclick + '"><i class="glyphicon glyphicon-' + icon + '"></i> ' + toolbar[i].name + ' </button>';
        }
        toolbarStr += '</div></div>';
        $('body').append(toolbarStr);
        LogUtil.log('按钮组创建完毕', 'TablePageCreatePublicUtil#createToolBar()');
    },
    createFormElement: function (form, titleWidth, inputWidth, preId) { // 自动生成表单控件
        var formElementStr = '';
        switch (form.type) {
            case 'hidden':
                if (form.id) {
                    formElementStr += '<input id="' + preId + form.id + '" type="hidden" name="' + form.name + '" value="' + form.value + '"/>';
                } else {
                    formElementStr += '<input type="hidden" name="' + form.name + '" value="' + form.value + '"/>';
                }
                break;
            case 'text':
                if (form.id) {
                    formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><input id="' + preId + form.id + '" type="text" name="' + form.name + '"  class="form-control" placeholder="请输入文本"></div></div>';
                } else {
                    formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><input type="text" name="' + form.name + '"  class="form-control" placeholder="请输入文本"></div></div>';
                }
                break;
            case 'select':
                var optionStr = '<option value = "">请点击下拉框选择</option>';
                if (form.items) { // 选项不为空
                    if (form.items instanceof Array) { // 类型为option数组
                        for (var i = 0; i < form.items.length; i++) {
                            optionStr += '<option value = "' + form.items[i].value + '">' + form.items[i].name + '</option>'
                        }
                    }
                }
                if (form.id) {
                    formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><select id="' + preId + form.id + '" class="form-control" name="' + form.name + '">' + optionStr + '</select></div></div>';
                } else {
                    formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><select class="form-control" name="' + form.name + '">' + optionStr + '</select></div></div>';
                }
                break;
            case 'checkbox':
                var optionStr = '';
                if (form.items) { // 选项不为空
                    if (form.items instanceof Array) { // 类型为option数组
                        for (var i = 0; i < form.items.length; i++) {
                            optionStr += '<label class="checkbox-inline"><input type="checkbox" name="' + form.name + '" value="' + form.items[i].value + '">' + form.items[i].name + '</label>'
                        }
                    }
                }
                formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '">' + optionStr + '</div></div>';
                break;
            case 'radio':
                var optionStr = '';
                if (form.items) { // 选项不为空
                    if (form.items instanceof Array) { // 类型为option数组
                        for (var i = 0; i < form.items.length; i++) {
                            optionStr += '<label class="radio-inline"><input type="radio" name="' + form.name + '" value="' + form.items[i].value + '">' + form.items[i].name + '</label>'
                        }
                    }
                }
                formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '">' + optionStr + '</div></div>';
                break;
            case 'images':
                formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><input type="file" id = "' + preId + form.id + '_fileinput" multiple name="file"  class="form-control"></div></div><input type="hidden" id = "' + preId + form.id + '" name="' + form.name + '"/><br>';
                break;
            case 'date':
                formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><input type="text" id = "' + preId + form.id + '"  name="' + form.name + '"  class="form-control"></div></div>';
                break;
            case 'datetime':
                formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><input type="text" id = "' + preId + form.id + '"  name="' + form.name + '"  class="form-control"></div></div>';
                break;
            case 'time':
                formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div class="col-sm-' + inputWidth + '"><input type="text" id = "' + preId + form.id + '"  name="' + form.name + '"  class="form-control"></div></div>';
                break;
            case 'div':
                formElementStr += '<div class="form-group"><label class="col-sm-' + titleWidth + ' control-label">' + form.label + '</label><div id = "' + preId + form.id + '" class="col-sm-' + inputWidth + '"></div></div>';
                break;
            default:
                break;
        }
        return formElementStr;
    },
    createQueryElement: function (query) {
        var queryElementStr = '';
        switch (query.type) {
            case 'text':
                queryElementStr += '<div class="form-group"><label>' +
                    query.name + '</label>&nbsp;<input type="text" class="form-control" id="' +
                    query.id + '" placeholder="' +
                    query.palceholder + '"></div>&nbsp;&nbsp;';
                break;
            case 'select' :
                var optionStr = '<option value = "0">请点击下拉框选择</option>';
                if (query.items) { // 选项不为空
                    if (query.items instanceof Array) { // 类型为option数组
                        for (var i = 0; i < query.items.length; i++) {
                            optionStr += '<option value = "' + query.items[i].value + '">' + query.items[i].name + '</option>'
                        }
                    } else if (typeof query.items === 'string') {
                        optionStr += TablePageCreatePublicUtil.getAjaxOptionItems(query.items);
                    }
                }
                queryElementStr += '<div class="form-group"><label>' + query.name + '</label><select id="' + query.id + '" class="form-control">' + optionStr + '</select></div>&nbsp;&nbsp;';
                break;
            default:
                break;
        }
        return queryElementStr;
    },
    getAjaxOptionItems: function (url) {
        var optionStr = '';
        var resp = AjaxUtil.getJson(url);
        if (resp) {
            for (var i = 0; i < resp.obj.length; i++) {
                optionStr += '<option value = "' + resp.obj[i].value + '">' + resp.obj[i].name + '</option>'
            }
        }
        return optionStr;
    },
    getRowFromTable: function (el, noneSelectMsg, manySelectMsg) {
        if (!noneSelectMsg) {
            noneSelectMsg = '您没有选中任何记录!'
        }
        if (!manySelectMsg) {
            manySelectMsg = '一次只能选中一条记录!'
        }
        var rows = $(el).bootstrapTable('getSelections');
        if (rows.length == 0) {
            SwalUtil.error(noneSelectMsg);
            return null;
        } else if (rows.length > 1) {
            SwalUtil.error(manySelectMsg);
            return null;
        } else {
            return rows[0];
        }
    },
    /**
     * @param modelArray,表单serializeArray的值
     * @returns 过滤空值后的表单数值
     */
    serializeFilterEmptyValue: function (modelArray) {
        var newModelArray = [];
        for (var i in modelArray) {
            if (modelArray[i].value) {
                newModelArray.push(modelArray[i]);
            }
        }
        return $.param(newModelArray);
    }
}